// 导入db模块
const db = require('../common/db/index')
// 导入加密模块
const aes = require('../common/aes/index')
const e = require('express')


// 定义用户类
class User {
    // 注册
    register(nickName, account, password, email) {
        // reslove响应的数据（完成），reject响应数据的状态（失败）
        return new Promise((reslove, reject) => {
            // 执行sql语句查询
            db.query(`select account from pre_user where account='${account}'`)
                .then(rows => {
                    if (rows.length == 0) {
                        // 未注册
                        // 对密码加密
                        let pwd = aes.aesEncrypt(password)
                        // console.log(pwd);

                        // 执行插入数据的sql语句
                        db.query(`insert into pre_user(nickName,account,password,email) values('${nickName}','${account}','${pwd}','${email}')`)
                            .then(
                                content => {
                                    reslove({
                                        code: 200,
                                        msg: '注册成功',
                                        status: content.changedRows == 0 ? '正常' : '异常'
                                    })
                                },
                                err => {
                                    reject({
                                        code: -1,
                                        msg: "注册失败",
                                        err
                                    })
                                }
                            )
                    }
                    else {
                        reslove({
                            code: 1,
                            msg: `${account}该用户账号已存在`
                        })
                    }
                })
                .catch(
                    err => {
                        reject({
                            code: -1,
                            mag: "服务后台错误",
                            err
                        })
                    }

                )
        })
    }
    // 登录
    login(account, password) {
        return new Promise((reslove, reject) => {
            // 执行查询语句
            db.query(`select account,password,id from pre_user where account='${account}'`)
                .then(
                    content => {
                        // 判断是否存在这个账号
                        if (content.length == 0) {
                            // 不存在
                            reject({
                                code: 404,
                                msg: "您还没有注册~"
                            })
                        }
                        else {
                            // 存在,判断密码是否正确
                            // 解密返回过来的密码
                            if (aes.aesDecrypt(password, content[0].password)) {
                                reslove({
                                    code: 200,
                                    msg: "登录成功~",
                                    id: content[0].id
                                })
                            }
                            // 密码错误
                            else {
                                reject({
                                    code: -1,
                                    msg: "账号或密码错误"
                                })
                            }
                        }
                    },
                    err => {
                        reject({
                            code: 500,
                            msg: "出错啦"
                        })
                    }
                )
                .catch(
                    err => {
                        reject({
                            code: -1,
                            msg: "后台出错",
                            err
                        })
                    }
                )
        })
    }
    // 登录(管理员)

    signin(account, password, role) {
        return new Promise((resolve, reject) => {
            db.query(`select  account, password, id, nickName from  pre_user  where account = '${account}' and role='${role}'`)
                .then(
                    rows => {
                        if (rows.length == 0) {
                            resolve({
                                code: 404,
                                msg: `该账号不存在，${account}`
                            })
                        }
                        else {
                            // 解构赋值
                            let [user] = rows;
                            // console.log("检查:",user);
                            if (user.password) {
                                // 通过布尔值 判断密码是否一致
                                // let isLogin = aes.aesDecrypt(明文（用户提交的参数）, 加密的（数据表中的字段）)
                                let isLogin = aes.aesDecrypt(password, user.password)
                                // console.log({isLogin})
                                if (isLogin) {
                                    // 给前端提示
                                    resolve({
                                        code: 200,
                                        msg: `${account},登录成功`,
                                        id: user.id,
                                        nickName: user.nickName
                                    })
                                }
                                else {
                                    // 提示
                                    resolve({
                                        code: -1,
                                        msg: `账号或密码错误`
                                    })
                                }
                            }
                        }
                    },
                    err => {
                        reject({
                            code: 500,
                            msg: "后台发生错误",
                            err
                        })
                    }
                )
        })
    }
    // 删除
    remove(id) {
        return new Promise((reslove, reject) => {
            db.query(`select account from pre_user where id=${id}`)
                .then(
                    rows => {
                        if (rows.length == 0) {
                            reslove({
                                code: -1,
                                msg: '该账号不存在'
                            })
                        }
                        else {
                            db.query(`delete from pre_user where id = '${id}'`)
                                .then(
                                    data => {
                                        reslove({
                                            code: 200,
                                            msg: '删除账号成功'
                                        })
                                    },
                                    err => {
                                        reject({
                                            cede: -1,
                                            msg: "删除失败",
                                            err
                                        })
                                    }
                                )

                        }
                    },
                    err => {
                        reject({
                            code: -1,
                            msg: "删除失败",
                            err
                        })
                    }
                )
        })
    }
    // 设置用户头像
    img(id, imgUrl) {
        return new Promise((reslove, reject) => {
            db.query(`select account from pre_user where id = '${id}'`)
                .then(
                    rows => {
                        if (rows.length == 0) {
                            reslove({
                                code: -1,
                                msg: '该账号不存在'
                            })
                        }
                        else {
                            db.query(`update pre_user set imgUrl='${imgUrl}' where id='${id}'`)
                                .then(
                                    content => {
                                        reslove({
                                            code: 200,
                                            msg: '设置用户头像成功',
                                            content
                                        })
                                    },
                                    err => {
                                        reject({
                                            code: -1,
                                            msg: "服务器错误失败"
                                        })
                                    }
                                )
                        }
                    },
                    err => {
                        reject({
                            code: -1,
                            msg: "后台错误",
                            err
                        })
                    }
                )

        })
    }

    // 编辑用户信息
    edit(id, age, sex, address, phone) {
        return new Promise((reslove, reject) => {
            db.query(`select account from pre_user where id = '${id}'`)
                .then(
                    rows => {
                        if (rows.length == 0) {
                            reslove({
                                code: -1,
                                msg: '该账号不存在'
                            })
                        }
                        else {
                            db.query(`update pre_user set age='${age}',sex='${sex}',address='${address}',phone='${phone}' where id='${id}'`)
                                .then(
                                    content => {
                                        reslove({
                                            code: 200,
                                            msg: '设置用户信息成功',
                                            content
                                        })
                                    },
                                    err => {
                                        reject({
                                            code: -1,
                                            msg: "服务器错误失败"
                                        })
                                    }
                                )
                        }
                    },
                    err => {
                        reject({
                            code: -1,
                            msg: "后台错误",
                            err
                        })
                    }
                )

        })
    }

    // 获取用详情户信息
    info(id) {
        return new Promise((reslove, reject) => {
            db.query(`select nickName,account,imgUrl,age,sex,address,email,phone from pre_user where id='${id}'`)
                .then(
                    rows => {
                        if (rows.length == 0) {
                            reject({
                                code: 404,
                                msg: "该用户不存在"
                            })
                        }
                        else {
                            reslove({
                                code: 200,
                                msg: "获取用户信息成功",
                                rows: rows[0]

                            })
                        }
                    },
                    err => {
                        reject({
                            code: -1,
                            msg: "后台出错",
                            err
                        })
                    }
                )
        })
    }
        // 获取用户列表(根据页码和页容量)
        list(page_num,page_size) {
            return new Promise((resolve, reject) => {
                db.query('select count(*) as total from pre_user')
                .then(
                    data =>{
                        // console.log({data})
                        return data
                    },
                    err=> {
                        reject({
                            code: -1,
                            msg: "统计失败",
                            err 
                        })
                    }
                )
                .then(
                    data => {
                        let num= ((parseInt(page_num) - 1) * parseInt(page_size))// 从哪个位置开始获取
                        let size= (parseInt(page_size)) // 获取多少条记录
                        db.query(`select * from pre_user limit ${num} , ${size}`)
                        .then(
                            rows=> {
                                resolve({
                                    code: 200,
                                    msg: "获取用户列表成功",
                                    total: data[0] && data[0].total, 
                                    result: [... rows] // 指定数量的用户列表
                                })
                            },
                            err=> {
                                reject({
                                    code: -1,
                                    msg: "获取用户列表失败",
                                    err 
                                })
                            }
                        )
                    }
                )
            })
        }

        // 获取用户列表(所有)
        listAll() {
            return new Promise((reslove,reject)=>{
                db.query('SELECT * FROM `pre_user`;')
                .then(content=>{
                    reslove({
                        code:200,
                        msg:"获取所有用户成功",
                        content
                    })
                },err=>{
                    reject({
                        code:-1,
                        msg:"获取所有用户失败",
                        err
                    })
                })
            })
        }

    // 设置用户密码（找回密码）
    pwd(account, password) {
        return new Promise((reslove, reject) => {
            db.query(`select account from pre_user where account = '${account}'`)
                .then(
                    rows => {
                        if (rows.length == 0) {
                            reslove({
                                code: -1,
                                msg: '该账号不存在'
                            })
                        }
                        else {
                            let pwd = aes.aesEncrypt(password)
                            db.query(`update pre_user set password='${pwd}' where account='${account}'`)
                                .then(
                                    content => {
                                        reslove({
                                            code: 200,
                                            msg: '设置用户密码成功',
                                            content
                                        })
                                    },
                                    err => {
                                        reject({
                                            code: -1,
                                            msg: "服务器错误失败"
                                        })
                                    }
                                )
                        }
                    },
                    err => {
                        reject({
                            code: -1,
                            msg: "后台错误",
                            err
                        })
                    }
                )

        })
    }

}

// 把这个类（数据模型）挂载到系统模块对象上
module.exports = User;